#include <iostream>
#include <string>
using namespace std;

class MyClock
{
public:
     MyClock(int h = 0,int m = 0, int s = 0);
     ~MyClock();

     MyClock operator -(const MyClock& c);
     MyClock operator -(const int s);

     MyClock operator ++();
     MyClock operator ++(int);

     void display();
     
private:
     int m_hour;
     int m_min;
     int m_sec;
};

MyClock::MyClock(int h,int m, int s)
     :m_hour(h),
      m_min(m),
      m_sec(s)
     {
          cout << "MyClock" << endl;
     };

MyClock::~MyClock()
{
     cout << "~MyClock" << endl;
}
//析构函数的调用次数与MyClock对象的创建次数相对应。析构函数会再每个对象生命周期结束时被自动调用。

MyClock MyClock::operator -(const MyClock& c)
{
     cout << "operator  -(const MyClock& c)" << endl;
     
     MyClock cc;
     
     cc.m_hour = this->m_hour - c.m_hour;
     cc.m_min = this->m_min - c.m_min;
     cc.m_sec = this->m_sec - c.m_sec;
     //每个非静态成员函数在编译时都会隐式地带上一个this指针，this指针的类型是ClassName*(指向类对象的指针)，在MyClock类的成员函数中，this指针的类型是MyClock*
     return cc;
}
MyClock MyClock::operator -(const int s)
{
     cout << "operator -(const int s)" << endl;
     
     MyClock cc;
     cc.m_hour = this->m_hour;
     cc.m_min = this->m_min;
     cc.m_sec = this->m_sec -s;

     return cc;
}

MyClock MyClock::operator ++()
{
     this -> m_sec += 1;
     
     return *this;
     
     //临时对象的析构:在c7 = c1++;语句中，后置自增操作会返回一个副本c，这是一个临时对象。在完成赋值操作c7 = c1++; 后，临时对象会被销毁，因此析构函数会再调用一次。
}

MyClock MyClock::operator ++(int)
{
     MyClock c = *this;

     ++*this;
     return c;
     /*
     1.参数:接收一个int参数，但仅是为了区分前置和后置自增运算符。因为是一个函数，具体实现的功能需要看函数体内如何实现。
     2.后置自增需要先返回旧值，所以先赋值当前的状态，再进行自增操作。这样返回的是自增前的状态
     3.创建一个副本c，保存当前对象的状态
     */

}

void MyClock::display()
{
     cout << m_hour << ":" << m_min << ":" << m_sec << endl;
}
int main()
{
     MyClock c1(9,39,52);
     c1.display();

     MyClock c2(19,20,34);
     c2.display();
     
     MyClock c6 = ++c2;
     c2.display();
     c6.display();

     MyClock c7 = c1++;
     c1.display();
     c7.display();

     return 0;
}
